/*********************************************************************************************************
* Software License Agreement (BSD License)															 *
* Author: Sebastien ROUX <sebastien.roux@eurecom.fr>							 *
*													 *
* Copyright (c) 2013, Eurecom						 *
* All rights reserved.											 *
* 													 *
* Redistribution and use of this software in source and binary forms, with or without modification, are  *
* permitted provided that the following conditions are met:						 *
* 													 *
* * Redistributions of source code must retain the above 						 *
*   copyright notice, this list of conditions and the 							 *
*   following disclaimer.										 *
*   													 *
* * Redistributions in binary form must reproduce the above 						 *
*   copyright notice, this list of conditions and the 							 *
*   following disclaimer in the documentation and/or other						 *
*   materials provided with the distribution.								 *
* 													 *
* * Neither the name of the Teraoka Laboratory nor the 							 *
*   names of its contributors may be used to endorse or 						 *
*   promote products derived from this software without 						 *
*   specific prior written permission of Teraoka Laboratory 						 *
*   													 *
* 													 *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 	 *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 	 *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF   *
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.								 *
*********************************************************************************************************/

#include <freeDiameter/extension.h>

/* The content of this file follows the same structure as dict_base_proto.c */

#define CHECK_dict_new( _type, _data, _parent, _ref )	\
	CHECK_FCT(  fd_dict_new( fd_g_config->cnf_dict, (_type), (_data), (_parent), (_ref))  );

#define CHECK_dict_search( _type, _criteria, _what, _result )	\
	CHECK_FCT(  fd_dict_search( fd_g_config->cnf_dict, (_type), (_criteria), (_what), (_result), ENOENT) );

struct local_rules_definition {
	char 			*avp_name;
	enum rule_position	position;
	int 			min;
	int			max;
};

#define RULE_ORDER( _position ) ((((_position) == RULE_FIXED_HEAD) || ((_position) == RULE_FIXED_TAIL)) ? 1 : 0 )

#define PARSE_loc_rules( _rulearray, _parent) {								\
	int __ar;											\
	for (__ar=0; __ar < sizeof(_rulearray) / sizeof((_rulearray)[0]); __ar++) {			\
		struct dict_rule_data __data = { NULL, 							\
			(_rulearray)[__ar].position,							\
			0, 										\
			(_rulearray)[__ar].min,								\
			(_rulearray)[__ar].max};							\
		__data.rule_order = RULE_ORDER(__data.rule_position);					\
		CHECK_FCT(  fd_dict_search( 								\
			fd_g_config->cnf_dict,								\
			DICT_AVP, 									\
			AVP_BY_NAME_ALL_VENDORS, 									\
			(_rulearray)[__ar].avp_name, 							\
			&__data.rule_avp, 0 ) );							\
		if ( !__data.rule_avp ) {								\
			TRACE_DEBUG(INFO, "AVP Not found: '%s'", (_rulearray)[__ar].avp_name );		\
			return ENOENT;									\
		}											\
		CHECK_FCT_DO( fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &__data, _parent, NULL),	\
			{											\
				TRACE_DEBUG(INFO, "Error on rule with AVP '%s'",	  			\
					 (_rulearray)[__ar].avp_name );			  			\
				return EINVAL;						  			\
			} );								  			\
	}										  			\
}

#define enumval_def_u32( _val_, _str_ ) \
		{ _str_, 		{ .u32 = _val_ }}

#define enumval_def_os( _len_, _val_, _str_ ) \
		{ _str_, 		{ .os = { .data = (unsigned char *)_val_, .len = _len_ }}}

/* Defines if there are any */

/* Dictionary */

int dict_s6a_init(char * conffile)
{
#define VENDOR_3GPP_Id  10415

	TRACE_ENTRY("%p", conffile);

	struct dict_object * vendor_dict;
	{
		struct dict_vendor_data vendor_data = { VENDOR_3GPP_Id, "3GPP" };
		CHECK_dict_new (DICT_VENDOR, &vendor_data, NULL, &vendor_dict);
	}

	struct dict_object * s6a_dict;
	{
		struct dict_application_data data = { 16777251, "Diameter S6a 3GPP" };
		CHECK_dict_new( DICT_APPLICATION, &data , NULL, &s6a_dict);
	}

	/* AVP section */
	{
		/* Loading the derived data formats */

		struct dict_object * Time_type;
		struct dict_object * Address_type;
		struct dict_object * UTF8String_type;

		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Address", &Address_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "UTF8String", &UTF8String_type);

		/* 3GPP-Charging-Characteristics */
		{
			struct dict_avp_data data = {
				13, 					/* Code */
				0, 					/* Vendor */
				"3GPP-Charging-Characteristics",		/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING					/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL);
		}

		/* Service-Selection - RFC 5778 */
		{
			struct dict_avp_data data = {
				493, 					/* Code */
				0, 					/* Vendor */
				"Service-Selection",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING 			/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL);
		}

		/* Max-Requested-Bandwidth-DL AVP - 3GPP TS 29.214  #5.3.14 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				515,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Max-Requested-Bandwidth-DL",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Max-Requested-Bandwidth-UL AVP - 3GPP TS 29.214  #5.3.15 */
		{
			struct dict_avp_data data = {
				516,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Max-Requested-Bandwidth-UL",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Visited-Network-Identifier AVP - 3GPP TS 29.229 #6.3.1 */
		{
			struct dict_avp_data data = {
				600,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Visited-Network-Identifier",			/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Confidentiality-Key AVP - 3GPP TS 29.229 #6.3.27 */
		{
			struct dict_avp_data data = {
				625,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Confidentiality-Key",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Integrity-Key AVP - 3GPP TS 29.229 #6.3.28 */
		{
			struct dict_avp_data data = {
				626,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Integrity-Key",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Feature-List-ID AVP - 3GPP TS 29.229 #6.3.29 */
		{
			struct dict_avp_data data = {
				629,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Feature-List-ID",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Feature-List AVP - 3GPP TS 29.229 #6.3.30 */
		{
			struct dict_avp_data data = {
				630,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Feature-List",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* MSISDN AVP - 3GPP TS 29.329 #6.3.2 */
		{
			struct dict_avp_data data = {
				701,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MSISDN",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Served-Party-IP-Address AVP - 3GPP TS 32.299 #7.2.187
		 * The Served-Party-IP-Address AVP (AVP code 848) is of type Address
		 * and holds the IP address of either the calling or called party,
		 * depending on whether the P-CSCF is in touch with the calling or the
		 * called party. This AVP is only provided by the P-CSCF.
		 */
		{
			struct dict_avp_data data = {
				848,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Served-Party-IP-Address",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , Address_type, NULL);
		}

		/* QoS-Class-Identifier AVP - 3GPP TS 29.212  #5.3.17 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(QoS-Class-Identifier)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_1		= { "QCI_1",					{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 	= { "QCI_2",					{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 	= { "QCI_3",					{ .i32 = 3 }};
			struct dict_enumval_data 	t_4		= { "QCI_4",					{ .i32 = 4 }};
			struct dict_enumval_data 	t_5 	= { "QCI_5",					{ .i32 = 5 }};
			struct dict_enumval_data 	t_6 	= { "QCI_6",					{ .i32 = 6 }};
			struct dict_enumval_data 	t_7 	= { "QCI_7",					{ .i32 = 7 }};
			struct dict_enumval_data 	t_8 	= { "QCI_8",					{ .i32 = 8 }};
			struct dict_enumval_data 	t_9		= { "QCI_9",					{ .i32 = 9 }};

			struct dict_avp_data data = {
				1028,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"QoS-Class-Identifier",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_1, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* RAT-Type AVP - 3GPP TS 29.212  #5.3.31 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_UNSIGNED32,	"Enumerated(RAT-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0		= { "WLAN",						{ .u32 = 0 }};
			struct dict_enumval_data 	t_1		= { "VIRTUAL",					{ .u32 = 1 }};
			struct dict_enumval_data 	t_1000 	= { "UTRAN",					{ .u32 = 1000 }};
			struct dict_enumval_data 	t_1001 	= { "GERAN",					{ .u32 = 1001 }};
			struct dict_enumval_data 	t_1002	= { "GAN",						{ .u32 = 1002 }};
			struct dict_enumval_data 	t_1003 	= { "HSPA_EVOLUTION",			{ .u32 = 1003 }};
			struct dict_enumval_data 	t_1004 	= { "EUTRAN",					{ .u32 = 1004 }};
			struct dict_enumval_data 	t_2000 	= { "CDMA2000_1X",				{ .u32 = 2000 }};
			struct dict_enumval_data 	t_2001 	= { "HRPD",						{ .u32 = 2001 }};
			struct dict_enumval_data 	t_2002	= { "UMB",						{ .u32 = 2002 }};
			struct dict_enumval_data 	t_2003 	= { "EHRPD",					{ .u32 = 2003 }};

			struct dict_avp_data data = {
				1032,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"RAT-Type",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1000 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1001 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1002 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1003 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1004 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2000 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2001 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2002 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2003 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Priority-Level AVP - 3GPP TS 29.272  #5.3.45 */
		{
			struct dict_avp_data data = {
				1046,			  /* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Priority-Level",		  /* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32  /* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Pre-emption-Capability AVP - 3GPP TS 29.212  #5.3.46 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Pre-emption-Capability)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0		= { "PRE-EMPTION_CAPABILITY_ENABLED",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 	= { "PRE-EMPTION_CAPABILITY_DISABLED",		{ .i32 = 1 }};

			struct dict_avp_data data = {
				1047,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Pre-emption-Capability",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Pre-emption-Vulnerability AVP - 3GPP TS 29.212  #5.3.47 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Pre-emption-Vulnerability)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0		= { "PRE-EMPTION_VULNERABILITY_ENABLED",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 	= { "PRE-EMPTION_VULNERABILITY_DISABLED",		{ .i32 = 1 }};

			struct dict_avp_data data = {
				1048,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Pre-emption-Vulnerability",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Allocation-Retention-Priority AVP - 3GPP TS 29.272 #5.3.32 */
		{
			/*

			 Allocation-Retention-Priority ::= < AVP Header: 1034 >
					{ Priority-Level }
					[ Pre-emption-Capability ]
					[ Pre-emption-Vulnerability ]

			 The Allocation-Retention-Priority AVP (AVP code 1034) is of type
			 Grouped, and it is used to indicate the priority of allocation and
			 retention, the pre-emption capability and pre-emption vulnerability
			 for the SDF if provided within the QoS-Information-AVP or for the
			 EPS default bearer if provided within the Default-EPS-Bearer-QoS AVP.
			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
				1034,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Allocation-Retention-Priority",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Priority-Level",				RULE_REQUIRED, -1,  1 }
				,{  "Pre-emption-Capability",		RULE_OPTIONAL, -1,  1 }
				,{  "Pre-emption-Vulnerability",	RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* PDP-Address AVP - 3GPP TS 32.299 #6.3.2 */
		{
			/*
			 * The PDP-Address-Prefix-Length AVP needs not be available for IPv6
			 * typed IP-address prefix length of 64 bits.
			 */
			struct dict_avp_data data = {
				1227,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PDP-Address",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , Address_type, NULL);
		}

		/* Subscriber-Status - 3GPP TS 29.272  #7.3.29 */
		{
			struct dict_object * type;
			struct dict_type_data	 	tdata = { AVP_TYPE_UNSIGNED32,	"Enumerated(Subscriber-Status)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "SERVICE_GRANTED",					{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "OPERATOR_DETERMINED_BARRING", 		{ .i32 = 1 }};

			struct dict_avp_data data = {
				1424,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Subscriber-Status",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE,	&tdata, NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_0,   type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1,   type, NULL);
			CHECK_dict_new( DICT_AVP,	 &data,  NULL, &type);
		}

		/* STN-SR AVP - 3GPP TS 29.272  #7.3.33 */
		{
			struct dict_avp_data data = {
				1433,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"STN-SR",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL);
		}

		/* ICS-Indicator AVP - 3GPP TS 29.272  #7.3.104 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(ICS-Indicator)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "FALSE",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "TRUE",				{ .i32 = 1 }};

			struct dict_avp_data data = {
				1491,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"ICS-Indicator",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* IMEI AVP - 3GPP TS 29.272  #7.3.4 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1402,				/* Code */
                VENDOR_3GPP_Id,					/* Vendor */
				"IMEI",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, &avp);
		}

		/* 3GPP2-MEID AVP - 3GPP TS 29.272  #7.3.6 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1471,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"3GPP2-MEID",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Software Version - 3GPP TS 29.272  #7.3.5 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1403,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Software-Version",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, &avp);
		}

		/* Terminal Information AVP - 3GPP TS 29.272 #7.3.3 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1401,				/* Code */
                VENDOR_3GPP_Id,					/* Vendor */
				"Terminal-Information",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "IMEI",				RULE_REQUIRED,  1, 1 }
				,{  "3GPP2-MEID",		RULE_REQUIRED,  1, 1 }
				,{  "Software-Version",	RULE_REQUIRED,  1, 1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* ULA-Flags - 3GPP TS 29.272  #7.3.8 */
		{
			struct dict_avp_data data = {
				1406,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"ULA-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Visited-PLMN-Id AVP - 3GPP TS 29.272  #7.3.9 */
		{
			struct dict_avp_data data = {
				1407,				/* Code */
                VENDOR_3GPP_Id,					/* Vendor */
				"Visited-PLMN-Id",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Number-Of-Requested-Vectors - 3GPP TS 29.272  #7.3.14 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1410,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Number-Of-Requested-Vectors",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Re-Synchronization-Info - 3GPP TS 29.272  #7.3.15 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1411,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Re-Synchronization-Info",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Immediate-Response-Preferred - 3GPP TS 29.272  #7.3.16 */
		{
			struct dict_avp_data data = {
				1412,				/* Code */
				VENDOR_3GPP_Id,     /* Vendor */
				"Immediate-Response-Preferred",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};
			
			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Requested-EUTRAN-Authentication-Info AVP - 3GPP TS 29.272  #7.3.11 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1408,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Requested-EUTRAN-Authentication-Info",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Number-Of-Requested-Vectors", 	RULE_OPTIONAL, -1, 1 }
				,{  "Immediate-Response-Preferred", 	RULE_OPTIONAL, -1, 1 }
				,{  "Re-Synchronization-Info", 		RULE_OPTIONAL, -1, 1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Requested-UTRAN-GERAN-Authentication-Info AVP - 3GPP TS 29.272  #7.3.12 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1409,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Requested-UTRAN-GERAN-Authentication-Info",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Number-Of-Requested-Vectors", 	RULE_OPTIONAL, -1, 1 }
				,{  "Immediate-Response-Preferred", 	RULE_OPTIONAL, -1, 1 }
				,{  "Re-Synchronization-Info", 		RULE_OPTIONAL, -1, 1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Item-Number AVP - 3GPP TS 29.272  #7.3.23 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1419,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Item-Number",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* RAND AVP - 3GPP TS 29.272  #7.3.53 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1447,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"RAND",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* XRES AVP - 3GPP TS 29.272  #7.3.54 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1448,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"XRES",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* AUTN AVP - 3GPP TS 29.272  #7.3.55 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1449,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"AUTN",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* SRES AVP - 3GPP TS 29.272  #7.3.60 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1454,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SRES",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* KASME AVP - 3GPP TS 29.272  #7.3.56 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1450,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"KASME",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Kc AVP - 3GPP TS 29.272  #7.3.59 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1453,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Kc",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Trace-Collection-Entity AVP - 3GPP TS 29.272  #7.3.96 */
		{
			struct dict_avp_data data = {
				1452,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Collection-Entity",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
		}

		/* E-UTRAN-Vector - 3GPP TS 29.272  #7.3.18 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1414,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"E-UTRAN-Vector",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Item-Number", 		RULE_OPTIONAL, -1,  1 }
				,{  "RAND", 			RULE_REQUIRED, -1,  1 }
				,{  "XRES", 			RULE_REQUIRED, -1,  1 }
				,{  "AUTN", 			RULE_REQUIRED, -1,  1 }
				,{  "KASME", 			RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* UTRAN-Vector - 3GPP TS 29.272  #7.3.19 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1415,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"UTRAN-Vector",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Item-Number", 			RULE_OPTIONAL, -1,  1 }
				,{  "RAND", 				RULE_REQUIRED, -1,  1 }
				,{  "XRES", 				RULE_REQUIRED, -1,  1 }
				,{  "AUTN", 				RULE_REQUIRED, -1,  1 }
				,{  "Confidentiality-Key", 	RULE_REQUIRED, -1,  1 }
				,{  "Integrity-Key", 		RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* GERAN-Vector - 3GPP TS 29.272  #7.3.20 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1416,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"GERAN-Vector",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Item-Number", 			RULE_OPTIONAL, -1,  1 }
				,{  "RAND", 				RULE_REQUIRED, -1,  1 }
				,{  "SRES", 				RULE_REQUIRED, -1,  1 }
				,{  "Kc", 					RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Authentication-Info - 3GPP TS 29.272  #7.3.17 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1413,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Authentication-Info",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "E-UTRAN-Vector", 		RULE_OPTIONAL, -1, -1 }
				,{  "UTRAN-Vector", 		RULE_OPTIONAL, -1, -1 }
				,{  "GERAN-Vector", 		RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Network-Access-Mode - 3GPP TS 29.272  #7.3.21 */
		{
			struct dict_object * type;
			struct dict_type_data	 	tdata = { AVP_TYPE_UNSIGNED32,	"Enumerated(Network-Access-Mode)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "PACKET_AND_CIRCUIT",	{ .u32 = 0 }};
			struct dict_enumval_data 	t_1 = { "ONLY_PACKET", 			{ .u32 = 1 }};

			struct dict_avp_data data = {
				1417,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Network-Access-Mode",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , type, NULL);
			CHECK_dict_new( DICT_AVP, &data , type, NULL);
		}

		/* HPLMN-ODB AVP - 3GPP TS 29.272  #7.3.22 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1418,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"HPLMN-ODB",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Cancellation-Type - 3GPP TS 29.272  #7.3.24 */
		{
			struct dict_object * type;
			struct dict_type_data	 	tdata = { AVP_TYPE_UNSIGNED32,	"Enumerated(Cancellation-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "MME_UPDATE_PROCEDURE",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "SGSN_UPDATE_PROCEDURE", 		{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "SUBSCRIPTION_WITHDRAWAL", 		{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "UPDATE_PROCEDURE_IWF", 		{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "INITIAL_ATTACH_PROCEDURE", 	{ .i32 = 4 }};

			struct dict_avp_data data = {
				1420,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Cancellation-Type",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE,	&tdata, NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_0,   type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1,   type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2,   type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3,   type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4,   type, NULL);
			CHECK_dict_new( DICT_AVP,	 &data,  NULL, &type);
		}

		/* DSR-Flags AVP - 3GPP TS 29.272  #7.3.25 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1421,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"DSR-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* DSA-Flags AVP - 3GPP TS 29.272  #7.3.26 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1422,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"DSA-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Context-Identifier AVP - 3GPP TS 29.272  #7.3.27 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1423,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Context-Identifier",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Operator-Determined-Barring AVP - 3GPP TS 29.272  #7.3.30 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1425,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Operator-Determined-Barring",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Access-Restriction-Data AVP - 3GPP TS 29.272  #7.3.31 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1426,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Access-Restriction-Data",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* APN-OI-Replacement AVP - 3GPP TS 29.272  #7.3.32 */
		{
			struct dict_avp_data data = {
				1427,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"APN-OI-Replacement",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL);
		}

		/* All-APN-Configurations-Included-Indicator AVP - 3GPP TS 29.272  #7.3.33 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(All-APN-Configurations-Included-Indicator)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "All_APN_CONFIGURATIONS_INCLUDED",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "MODIFIED/ADDED_APN_CONFIGURATIONS_INCLUDED", 	{ .i32 = 1 }};

			struct dict_avp_data data = {
				1428,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"All-APN-Configurations-Included-Indicator",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* PDN-Type AVP - 3GPP TS 29.272  #7.3.62 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(PDN-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "IPv4",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "IPv6",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "IPv4v6", 			{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "IPv4_OR_IPv6", 	{ .i32 = 3 }};

			struct dict_avp_data data = {
				1456,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PDN-Type",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* EPS-Subscribed-QoS-Profile AVP - 3GPP TS 29.272 #7.3.37 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1431,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"EPS-Subscribed-QoS-Profile",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "QoS-Class-Identifier",				RULE_REQUIRED, -1,  1 }
				,{ "Allocation-Retention-Priority",		RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* VPLMN-Dynamic-Address-Allowed AVP - 3GPP TS 29.272  #7.3.38 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(VPLMN-Dynamic-Address-Allowed)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "NOTALLOWED",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "ALLOWED", 		{ .i32 = 1 }};

			struct dict_avp_data data = {
				1432,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"VPLMN-Dynamic-Address-Allowed",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Alert-Reason AVP - 3GPP TS 29.272  #7.3.83 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Alert-Reason)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "UE_PRESENT",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "UE_MEMORY_AVAILABLE", 	{ .i32 = 1 }};

			struct dict_avp_data data = {
				1434,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Alert-Reason",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* PDN-GW-Allocation-Type AVP - 3GPP TS 29.272  #7.3.44 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(PDN-GW-Allocation-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "STATIC",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "DYNAMIC", 	{ .i32 = 1 }};

			struct dict_avp_data data = {
				1438,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PDN-GW-Allocation-Type",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Expiration-Date AVP - 3GPP TS 29.272  #7.3.80 */
		{
			struct dict_avp_data data = {
				1439,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Expiration-Date",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , Time_type, NULL);
		}

		/* CSG-Id AVP - 3GPP TS 29.272 #7.3.79 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1437,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"CSG-Id",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* AMBR AVP - 3GPP TS 29.272 #7.3.41 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1435,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"AMBR",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Max-Requested-Bandwidth-UL",		RULE_REQUIRED, -1,  1 }
				,{ "Max-Requested-Bandwidth-DL",		RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Specific-APN-Info AVP - 3GPP TS 29.272  #7.3.82 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1472,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Specific-APN-Info",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Service-Selection",					RULE_REQUIRED, -1,  1 }
				,{ "MIP6-Agent-Info",					RULE_REQUIRED, -1,  1 }
				,{ "Visited-Network-Identifier",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* SIPTO-Permission AVP - 3GPP TS 29.272  #7.3.135 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(SIPTO-Permission)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "SIPTO_ALLOWED",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "SIPTO_NOTALLOWED",				{ .i32 = 1 }};

			struct dict_avp_data data = {
				1613,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SIPTO-Permission",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* LIPA-Permission AVP - 3GPP TS 29.272 #7.3.133 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(LIPA-Permission)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "LIPA-PROHIBITED",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1  = { "LIPA-ONLY",					{ .i32 = 1 }};
			struct dict_enumval_data 	t_2  = { "LIPA-CONDITIONAL",			{ .i32 = 2 }};

			struct dict_avp_data data = {
				1618,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"LIPA-Permission",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);

			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* List-Of-Measurements AVP - 3GPP TS 29.272 #7.3.139 */
		{
			struct dict_avp_data data = {
				1625,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"List-Of-Measurements",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Reporting-Trigger AVP - 3GPP TS 29.272 #7.3.140 */
		{
			struct dict_avp_data data = {
				1626,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Reporting-Trigger",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Report-Interval AVP - 3GPP TS 29.272 #7.3.141 and TS 32.422 #5.10.5 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Report-Interval)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "250ms",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1  = { "500ms",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2  = { "1000ms",				{ .i32 = 2 }};
			struct dict_enumval_data 	t_3  = { "2000ms",				{ .i32 = 3 }};
			struct dict_enumval_data 	t_4  = { "3000ms",				{ .i32 = 4 }};
			struct dict_enumval_data 	t_5  = { "4000ms",				{ .i32 = 5 }};
			struct dict_enumval_data 	t_6  = { "6000ms",				{ .i32 = 6 }};
			struct dict_enumval_data 	t_7  = { "8000ms",				{ .i32 = 7 }};
			struct dict_enumval_data 	t_8  = { "12000ms",				{ .i32 = 8 }};
			struct dict_enumval_data 	t_9  = { "16000ms",				{ .i32 = 9 }};
			struct dict_enumval_data 	t_10 = { "20000ms",				{ .i32 = 10 }};
			struct dict_enumval_data 	t_11 = { "24000ms",				{ .i32 = 11 }};
			struct dict_enumval_data 	t_12 = { "28000ms",				{ .i32 = 12 }};
			struct dict_enumval_data 	t_13 = { "32000ms",				{ .i32 = 13 }};
			struct dict_enumval_data 	t_14 = { "64000ms",				{ .i32 = 14 }};
			/* Possible in LTE */
			struct dict_enumval_data 	t_15 = { "120ms",				{ .i32 = 15 }};
			struct dict_enumval_data 	t_16 = { "240ms",				{ .i32 = 16 }};
			struct dict_enumval_data 	t_17 = { "480ms",				{ .i32 = 17 }};
			struct dict_enumval_data 	t_18 = { "640ms",				{ .i32 = 18 }};
			struct dict_enumval_data 	t_19 = { "1024ms",				{ .i32 = 19 }};
			struct dict_enumval_data 	t_20 = { "2048ms",				{ .i32 = 20 }};
			struct dict_enumval_data 	t_21 = { "5120ms",				{ .i32 = 21 }};
			struct dict_enumval_data 	t_22 = { "10240ms",				{ .i32 = 22 }};
			struct dict_enumval_data 	t_23 = { "1min",				{ .i32 = 23 }};
			struct dict_enumval_data 	t_24 = { "6min",				{ .i32 = 24 }};
			struct dict_enumval_data 	t_25 = { "12min",				{ .i32 = 25 }};
			struct dict_enumval_data 	t_26 = { "30min",				{ .i32 = 26 }};
			struct dict_enumval_data 	t_27 = { "60min",				{ .i32 = 27 }};

			struct dict_avp_data data = {
				1627,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Report-Interval",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_15 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_16 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_17 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_18 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_19 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_20 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_21 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_22 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_23 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_24 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_25 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_26 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_27 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Report-Amount AVP - 3GPP TS 29.272 #7.3.142 and TS 32.422 #5.10.6 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Report-Amount)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "1",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1  = { "2",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2  = { "4",				{ .i32 = 2 }};
			struct dict_enumval_data 	t_3  = { "8",				{ .i32 = 3 }};
			struct dict_enumval_data 	t_4  = { "16",				{ .i32 = 4 }};
			struct dict_enumval_data 	t_5  = { "32",				{ .i32 = 5 }};
			struct dict_enumval_data 	t_6  = { "64",				{ .i32 = 6 }};
			struct dict_enumval_data 	t_7  = { "infinity",		{ .i32 = 7 }};

			struct dict_avp_data data = {
				1628,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Report-Amount",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL);

			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Event-Threshold-RSRP AVP - 3GPP TS 29.272 #7.3.143 */
		{
			struct dict_avp_data data = {
				1629,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Event-Threshold-RSRP",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Event-Threshold-RSRQ AVP - 3GPP TS 29.272 #7.3.144 */
		{
			struct dict_avp_data data = {
				1630,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Event-Threshold-RSRQ",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Logging-Interval AVP - 3GPP TS 29.272 #7.3.145 and TS 32.422 #5.10.8 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Logging-Interval)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "1.28",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1  = { "2.56",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2  = { "5.12",				{ .i32 = 2 }};
			struct dict_enumval_data 	t_3  = { "10.24",				{ .i32 = 3 }};
			struct dict_enumval_data 	t_4  = { "20.48",				{ .i32 = 4 }};
			struct dict_enumval_data 	t_5  = { "30.72",				{ .i32 = 5 }};
			struct dict_enumval_data 	t_6  = { "40.96",				{ .i32 = 6 }};
			struct dict_enumval_data 	t_7  = { "61.44",				{ .i32 = 7 }};

			struct dict_avp_data data = {
				1631,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Logging-Interval",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL);

			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Logging-Duration AVP - 3GPP TS 29.272 #7.3.145 and TS 32.422 #5.10.9 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Logging-Duration)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "600sec",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1  = { "1200sec",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2  = { "2400sec",				{ .i32 = 2 }};
			struct dict_enumval_data 	t_3  = { "3600sec",				{ .i32 = 3 }};
			struct dict_enumval_data 	t_4  = { "5400sec",				{ .i32 = 4 }};
			struct dict_enumval_data 	t_5  = { "7200sec",				{ .i32 = 5 }};

			struct dict_avp_data data = {
				1632,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Logging-Duration",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);

			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* APN-Configuration AVP - 3GPP TS 29.272 #7.3.35 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1430,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"APN-Configuration",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Context-Identifier",			RULE_REQUIRED, -1,  1 }
				,{ "Served-Party-IP-Address",		RULE_OPTIONAL, -1,  2 }
				,{ "PDN-Type",						RULE_REQUIRED, -1,  1 }
				,{ "Service-Selection",				RULE_REQUIRED, -1,  1 }
				,{ "EPS-Subscribed-QoS-Profile",	RULE_OPTIONAL, -1,  1 }
				,{ "VPLMN-Dynamic-Address-Allowed",	RULE_OPTIONAL, -1,  1 }
				,{ "MIP6-Agent-Info",				RULE_OPTIONAL, -1,  1 }
				,{ "Visited-Network-Identifier",	RULE_OPTIONAL, -1,  1 }
				,{ "PDN-GW-Allocation-Type",		RULE_OPTIONAL, -1,  1 }
				,{ "3GPP-Charging-Characteristics",	RULE_OPTIONAL, -1,  1 }
				,{ "AMBR",							RULE_OPTIONAL, -1,  1 }
				,{ "Specific-APN-Info",				RULE_OPTIONAL, -1, -1 }
				,{ "APN-OI-Replacement",			RULE_OPTIONAL, -1,  1 }
				,{ "SIPTO-Permission",				RULE_OPTIONAL, -1,  1 }
				,{ "LIPA-Permission",				RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* APN-Configuration-Profile AVP - 3GPP TS 29.272 #7.3.34 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1429,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"APN-Configuration-Profile",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Context-Identifier",						RULE_REQUIRED, -1,  1 }
				,{ "All-APN-Configurations-Included-Indicator",	RULE_REQUIRED, -1,  1 }
				,{ "APN-Configuration",							RULE_REQUIRED, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* CSG-Subscription-Data AVP - 3GPP TS 29.272 #7.3.78 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1436,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"CSG-Subscription-Data",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "CSG-Id",					RULE_REQUIRED, -1,  1 }
				,{ "Expiration-Date",			RULE_OPTIONAL, -1,  1 }
				,{ "Service-Selection",			RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* RAT-Frequency-Selection-Priority-ID AVP - 3GPP TS 29.272 #7.3.46 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1440,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"RAT-Frequency-Selection-Priority-ID",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* IDA-Flags AVP - 3GPP TS 29.272 #7.3.47 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1441,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"IDA-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* PUA-Flags AVP - 3GPP TS 29.272 #7.3.48 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1442,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PUA-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* NOR-Flags AVP - 3GPP TS 29.272 #7.3.49 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1443,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"NOR-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* User-Id AVP - 3GPP TS 29.272 #7.3.50 */
		{
			struct dict_avp_data data = {
				1444,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"User-Id",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL);
		}

		/* Equipment-Status AVP - 3GPP TS 29.272  #7.3.51 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Equipment-Status)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "WHITELISTED",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "BLACKLISTED", 	{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "GREYLISTED", 	{ .i32 = 2 }};

			struct dict_avp_data data = {
				1445,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Equipment-Status",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Regional-Subscription-Zone-Code AVP - 3GPP TS 29.272  #7.3.52 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1446,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Regional-Subscription-Zone-Code",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Roaming-Restricted-Due-To-Unsupported-Feature AVP - 3GPP TS 29.272  #7.3.81 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Roaming-Restricted-Due-To-Unsupported-Feature)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "Roaming-Restricted-Due-To-Unsupported-Feature",	{ .i32 = 0 }};

			struct dict_avp_data data = {
				1457,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Roaming-Restricted-Due-To-Unsupported-Feature",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Trace-Reference AVP - 3GPP TS 29.272  #7.3.64 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1459,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Reference",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Trace-Depth AVP - 3GPP TS 29.272  #7.3.67 and 3GPP TS 32.422  #5.3 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Trace-Depth)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "Minimum",									{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "Medium",									{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "Maximum",									{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "MinimumWithoutVendorSpecificExtension",	{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "MediumWithoutVendorSpecificExtension",		{ .i32 = 4 }};
			struct dict_enumval_data 	t_5 = { "MaximumWithoutVendorSpecificExtension",	{ .i32 = 5 }};

			struct dict_avp_data data = {
				1462,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Depth",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Trace-NE-Type-List AVP - 3GPP TS 29.272  #7.3.68 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1463,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-NE-Type-List",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Trace-Event-List AVP - 3GPP TS 29.272  #7.3.69 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1464,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Interface-List",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Trace-Event-List AVP - 3GPP TS 29.272  #7.3.70 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1465,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Event-List",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* OMC-Id AVP - 3GPP TS 29.272  #7.3.71 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1466,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"OMC-Id",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Complete-Data-List-Included-Indicator AVP - 3GPP TS 29.272  #7.3.73 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Complete-Data-List-Included-Indicator)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "All_PDP_CONTEXTS_INCLUDED",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "MODIFIED/ADDED_PDP CONTEXTS_INCLUDED", 	{ .i32 = 1 }};

			struct dict_avp_data data = {
				1468,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Complete-Data-List-Included-Indicator",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* PDP-Type AVP - 3GPP TS 29.272  #7.3.75 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1470,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PDP-Type",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* GMLC-Number AVP - 3GPP TS 29.272  #7.3.85 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1474,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"GMLC-Number",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* SS-Code AVP - 3GPP TS 29.272  #7.3.87 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1476,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SS-Code",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* SS-Status AVP - 3GPP TS 29.272  #7.3.88 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1477,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SS-Status",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* Notification-To-UE-User AVP - 3GPP TS 29.272  #7.3.89 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Notification-To-UE-User)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "NOTIFY_LOCATION_ALLOWED",								{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "NOTIFYANDVERIFY_LOCATION_ALLOWED_IF_NO_RESPONSE",		{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "NOTIFYANDVERIFY_LOCATION_NOT_ALLOWED_IF_NO_RESPONSE",	{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "LOCATION_NOT_ALLOWED",									{ .i32 = 3 }};

			struct dict_avp_data data = {
				1478,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Notification-To-UE-User",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* Client-Identity AVP - 3GPP TS 29.272  #7.3.91 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1480,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Client-Identity",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* GMLC-Restriction AVP - 3GPP TS 29.272  #7.3.92 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(GMLC-Restriction)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "GMLC_LIST",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "HOME_COUNTRY",				{ .i32 = 1 }};

			struct dict_avp_data data = {
				1481,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"GMLC-Restriction",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* PLMN-Client AVP - 3GPP TS 29.272  #7.3.92 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(PLMN-Client)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "BROADCAST_SERVICE",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "O_AND_M_HPLMN",					{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "O_AND_M_VPLMN",					{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "ANONYMOUS_LOCATION",				{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "TARGET_UE_SUBSCRIBED_SERVICE",		{ .i32 = 4 }};

			struct dict_avp_data data = {
				1482,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PLMN-Client",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* ServiceTypeIdentity AVP - 3GPP TS 29.272  #7.3.95 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1484,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"ServiceTypeIdentity",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
		}

		/* QoS-Subscribed - 3GPP TS 29.272 #7.3.77 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1404,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"QoS-Subscribed",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* ULR-Flags - 3GPP TS 29.272  #7.3.7 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1405,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"ULR-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Ext-PDP-Type AVP - 3GPP TS 29.272  #7.3.75A */
		{
			struct dict_avp_data data = {
				1620,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Ext-PDP-Type",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Ext-PDP-Address AVP - 3GPP TS 29.272  #7.3.129 */
		{
			struct dict_avp_data data = {
				1621,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Ext-PDP-Address",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
		}

		/* TS-Code AVP - 3GPP TS 29.272  #7.3.100 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1487,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"TS-Code",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* External-Client AVP - 3GPP TS 29.272 #7.3.90 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1479,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"External-Client",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Client-Identity",				RULE_REQUIRED, -1,  1 }
				,{ "GMLC-Restriction",				RULE_OPTIONAL, -1,  1 }
				,{ "Notification-To-UE-User",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Service-Type AVP - 3GPP TS 29.272 #7.3.94 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1483,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Service-Type",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "ServiceTypeIdentity",			RULE_REQUIRED, -1,  1 }
				,{ "GMLC-Restriction",				RULE_OPTIONAL, -1,  1 }
				,{ "Notification-To-UE-User",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* LCS-PrivacyException AVP - 3GPP TS 29.272 #7.3.86 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1475,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"LCS-PrivacyException",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "SS-Code",						RULE_REQUIRED, -1,  1 }
				,{ "SS-Status",						RULE_REQUIRED, -1,  1 }
				,{ "Notification-To-UE-User",		RULE_OPTIONAL, -1,  1 }
				,{ "External-Client",				RULE_OPTIONAL, -1, -1 }
				,{ "PLMN-Client",					RULE_OPTIONAL, -1, -1 }
				,{ "Service-Type",					RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* MO-LR AVP - 3GPP TS 29.272 #7.3.96 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1485,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MO-LR",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "SS-Code",			RULE_REQUIRED, -1,  1 }
				,{ "SS-Status",			RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* LCS-Info AVP - 3GPP TS 29.272 #7.3.84 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1473,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"LCS-Info",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "GMLC-Number",				RULE_OPTIONAL, -1, -1 }
				,{ "LCS-PrivacyException",		RULE_OPTIONAL, -1, -1 }
				,{ "MO-LR",						RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* PDP-Context AVP - 3GPP TS 29.272 #7.3.74 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1469,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PDP-Context",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Context-Identifier",			RULE_REQUIRED, -1,  1 }
				,{ "PDP-Type",						RULE_REQUIRED, -1,  1 }
				,{ "PDP-Address",					RULE_OPTIONAL, -1,  1 }
				,{ "QoS-Subscribed",				RULE_REQUIRED, -1,  1 }
				,{ "VPLMN-Dynamic-Address-Allowed",	RULE_OPTIONAL, -1,  1 }
				,{ "Service-Selection",				RULE_REQUIRED, -1,  1 }
				,{ "3GPP-Charging-Characteristics",	RULE_OPTIONAL, -1,  1 }
				,{ "Ext-PDP-Type",					RULE_OPTIONAL, -1,  1 }
				,{ "Ext-PDP-Address",				RULE_OPTIONAL, -1,  1 }
				,{ "AMBR",							RULE_OPTIONAL, -1,  1 }
				,{ "SIPTO-Permission",				RULE_OPTIONAL, -1,  1 }
				,{ "LIPA-Permission",				RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* GPRS-Subscription-Data AVP - 3GPP TS 29.272  #7.3.72 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1467,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"GPRS-Subscription-Data",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Complete-Data-List-Included-Indicator",		RULE_REQUIRED, -1,  1 }
				,{ "PDP-Context",								RULE_REQUIRED, -1,  50 }
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Teleservice-List AVP - 3GPP TS 29.272 #7.3.99 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1486,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Teleservice-List",				/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "TS-Code",			RULE_REQUIRED, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Call-Barring-Infor-List AVP - 3GPP TS 29.272 #7.3.101 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1488,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Call-Barring-Infor-List",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				{ "SS-Code",		RULE_REQUIRED,  1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* SGSN-Number AVP - 3GPP TS 29.272  #7.3.102 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1489,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SGSN-Number",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* IDR-Flags AVP - 3GPP TS 29.272  #7.3.103 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				1490,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"IDR-Flags",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* IMS-Voice-Over-PS-Sessions-Supported AVP - 3GPP TS 29.272  #7.3.106 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(IMS-Voice-Over-PS-Sessions-Supported)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "NOT_SUPPORTED",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "SUPPORTED",				{ .i32 = 1 }};

			struct dict_avp_data data = {
				1492,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"IMS-Voice-Over-PS-Sessions-Supported",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , avp, NULL);
		}

		/* SGSN-Number AVP - 3GPP TS 29.272  #7.3.102 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Homogeneous-Support-of-IMS-Voice-Over-PSSessions)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "NOT_SUPPORTED",						{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "SUPPORTED", 							{ .i32 = 1 }};

			struct dict_avp_data data = {
				1493,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Homogeneous-Support-of-IMS-Voice-Over-PSSessions",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Last-UE-Activity-Time AVP - 3GPP TS 29.272 #7.3.108 */
		{
			struct dict_avp_data data = {
				1494,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Last-UE-Activity-Time",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , Time_type, NULL);
		}

		/* E-UTRAN-Cell-Global-Identity AVP - 3GPP TS 29.272 #7.3.117 */
		{
			struct dict_avp_data data = {
				1602,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"E-UTRAN-Cell-Global-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Tracking-Area-Identity AVP - 3GPP TS 29.272 #7.3.118 */
		{
			struct dict_avp_data data = {
				1603,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Tracking-Area-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Cell-Global-Identity AVP - 3GPP TS 29.272 #7.3.119 */
		{
			struct dict_avp_data data = {
				1604,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Cell-Global-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Routing-Area-Identity AVP - 3GPP TS 29.272 #7.3.120 */
		{
			struct dict_avp_data data = {
				1605,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Routing-Area-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Location-Area-Identity AVP - 3GPP TS 29.272 #7.3.121 */
		{
			struct dict_avp_data data = {
				1606,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Location-Area-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Service-Area-Identity AVP - 3GPP TS 29.272 #7.3.122 */
		{
			struct dict_avp_data data = {
				1607,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Service-Area-Identity",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Geographical-Information AVP - 3GPP TS 29.272 #7.3.123 */
		{
			struct dict_avp_data data = {
				1608,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Geographical-Information",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Geodetic-Information AVP - 3GPP TS 29.272 #7.3.124 */
		{
			struct dict_avp_data data = {
				1609,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Geodetic-Information",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		}

		/* Current-Location-Retrieved AVP - 3GPP TS 29.272  #7.3.125 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Current-Location-Retrieved)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "ACTIVE-LOCATION-RETRIEVAL",		{ .i32 = 0 }};

			struct dict_avp_data data = {
				1610,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Current-Location-Retrieved",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Age-Of-Location-Information AVP - 3GPP TS 29.272 #7.3.126 */
		{
			struct dict_avp_data data = {
				1611,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Age-Of-Location-Information",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* UE-SRVCC-Capability AVP - 3GPP TS 29.272  #7.3.130 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(UE-SRVCC-Capability)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "UE-SRVCC-NOT-SUPPORTED",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "UE-SRVCC-SUPPORTED",			{ .i32 = 1 }};

			struct dict_avp_data data = {
				1615,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"UE-SRVCC-Capability",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* MPS-Priority AVP - 3GPP TS 29.272 #7.3.131 */
		{
			struct dict_avp_data data = {
				1616,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MPS-Priority",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* VPLMN-LIPA-Allowed AVP - 3GPP TS 29.272  #7.3.132 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(VPLMN-LIPA-Allowed)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "LIPA-NOTALLOWED",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "LIPA-ALLOWED",			{ .i32 = 1 }};

			struct dict_avp_data data = {
				1617,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"VPLMN-LIPA-Allowed",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Subscribed-Periodic-RAU-TAU-Timer AVP - 3GPP TS 29.272 #7.3.134 */
		{
			struct dict_avp_data data = {
				1619,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Subscribed-Periodic-RAU-TAU-Timer",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Job-Type AVP - 3GPP TS 29.272 #7.3.132 and 3GPP TS 32.422 #5.10.1 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Job-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "Immediate-MDT-Only",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "Logged-MDT-only",				{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "Trace-Only",					{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "Immediate-MDT-and-Trace",		{ .i32 = 3 }};

			struct dict_avp_data data = {
				1623,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Job-Type",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* Relay-Node-Indicator AVP - 3GPP TS 29.272  #7.3.147 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Relay-Node-Indicator)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "NOT_RELAY_NODE",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "RELAY_NODE",			{ .i32 = 1 }};

			struct dict_avp_data data = {
				1633,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Relay-Node-Indicator",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* MDT-User-Consent AVP - 3GPP TS 29.272  #7.3.148 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(MDT-User-Consent)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "CONSENT_NOT_GIVEN",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "CONSENT_GIVEN",			{ .i32 = 1 }};

			struct dict_avp_data data = {
				1634,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MDT-User-Consent",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* PUR-Flags AVP - 3GPP TS 29.272 #7.3.149 */
		{
			struct dict_avp_data data = {
				1635,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"PUR-Flags",			/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_UNSIGNED32		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* User-State AVP - 3GPP TS 29.272 #7.3.114 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(User-State)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "DETACHED",									{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "ATTACHED_NOT_REACHABLE_FOR_PAGING", 		{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "ATTACHED_REACHABLE_FOR_PAGING", 			{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "CONNECTED_NOT_REACHABLE_FOR_PAGING", 		{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "CONNECTED_REACHABLE_FOR_PAGING", 			{ .i32 = 4 }};
			struct dict_enumval_data 	t_5 = { "NETWORK_DETERMINED_NOT_REACHABLE", 		{ .i32 = 5 }};

			struct dict_avp_data data = {
				1499,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"User-State",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* MME-User-State AVP - 3GPP TS 29.272 #7.3.112 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1497,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MME-User-State",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				{ "User-State",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* SGSN-User-State AVP - 3GPP TS 29.272 #7.3.113 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1498,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SGSN-User-State",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				{ "User-State",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* EPS-User-State AVP - 3GPP TS 29.272 #7.3.110 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1495,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"EPS-User-State",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "MME-User-State",		RULE_OPTIONAL, -1,  1 }
				,{ "SGSN-User-State",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* MME-Location-Information AVP - 3GPP TS 29.272 #7.3.115 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1600,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MME-Location-Information",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "E-UTRAN-Cell-Global-Identity",				RULE_OPTIONAL, -1,  1 }
				,{ "Tracking-Area-Identity",			RULE_OPTIONAL, -1,  1 }
				,{ "Geographical-Information",			RULE_OPTIONAL, -1,  1 }
				,{ "Geodetic-Information",				RULE_OPTIONAL, -1,  1 }
				,{ "Current-Location-Retrieved",		RULE_OPTIONAL, -1,  1 }
				,{ "Age-Of-Location-Information",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* SGSN-Location-Information AVP - 3GPP TS 29.272 #7.3.116 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1601,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"SGSN-Location-Information",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Cell-Global-Identity",				RULE_OPTIONAL, -1,  1 }
				,{ "Location-Area-Identity",			RULE_OPTIONAL, -1,  1 }
				,{ "Service-Area-Identity",				RULE_OPTIONAL, -1,  1 }
				,{ "Routing-Area-Identity",				RULE_OPTIONAL, -1,  1 }
				,{ "Geographical-Information",			RULE_OPTIONAL, -1,  1 }
				,{ "Geodetic-Information",				RULE_OPTIONAL, -1,  1 }
				,{ "Current-Location-Retrieved",		RULE_OPTIONAL, -1,  1 }
				,{ "Age-Of-Location-Information",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Area-Scope AVP - 3GPP TS 29.272  #7.3.138 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1624,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Area-Scope",			/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Cell-Global-Identity",				RULE_OPTIONAL, -1, -1 }
				,{ "E-UTRAN-Cell-Global-Identity",		RULE_OPTIONAL, -1, -1 }
				,{ "Routing-Area-Identity",				RULE_OPTIONAL, -1, -1 }
				,{ "Location-Area-Identity",			RULE_OPTIONAL, -1, -1 }
				,{ "Tracking-Area-Identity",			RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* MDT-Configuration AVP - 3GPP TS 29.272 #7.3.136 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1622,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"MDT-Configuration",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Job-Type",					RULE_REQUIRED, -1,  1 }
				,{ "Area-Scope",				RULE_OPTIONAL, -1,  1 }
				,{ "List-Of-Measurements",		RULE_OPTIONAL, -1,  1 }
				,{ "Reporting-Trigger",			RULE_OPTIONAL, -1,  1 }
				,{ "Report-Interval",			RULE_OPTIONAL, -1,  1 }
				,{ "Report-Amount",				RULE_OPTIONAL, -1,  1 }
				,{ "Event-Threshold-RSRP",		RULE_OPTIONAL, -1,  1 }
				,{ "Event-Threshold-RSRQ",		RULE_OPTIONAL, -1,  1 }
				,{ "Logging-Interval",			RULE_OPTIONAL, -1,  1 }
				,{ "Logging-Duration",			RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* EPS-Location-Information AVP - 3GPP TS 29.272 #7.3.111 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1496,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"EPS-Location-Information",		/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "MME-Location-Information",		RULE_OPTIONAL, -1,  1 }
				,{ "SGSN-Location-Information",		RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Active-APN AVP - 3GPP TS 29.173  #7.3.127 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1612,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Active-APN",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Context-Identifier",				RULE_REQUIRED, -1,  1 }
				,{ "Service-Selection",					RULE_OPTIONAL, -1,  1 }
				,{ "MIP6-Agent-Info",					RULE_OPTIONAL, -1,  1 }
				,{ "Visited-Network-Identifier",		RULE_OPTIONAL, -1,  1 }
				,{ "Specific-APN-Info",					RULE_OPTIONAL, -1, -1 }
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Error-Diagnostic AVP - 3GPP TS 29.272  #7.3.128 */
		{
			struct dict_object * avp;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Error-Diagnostic)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "GPRS_DATA_SUBSCRIBED",				{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "NO_GPRS_DATA_SUBSCRIBED", 			{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "ODB-ALL-APN", 						{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "ODB-HPLMN-APN", 					{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "ODB-VPLMN-APN", 					{ .i32 = 4 }};

			struct dict_avp_data data = {
				1614,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Error-Diagnostic",			/* Name */
				AVP_FLAG_VENDOR,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_INTEGER32		/* base type of data */
			};

			CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp);
			CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL);
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* GMLC-Address AVP - 3GPP TS 29.173  #6.4.7 */
		{
			struct dict_avp_data data = {
				2405,					/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"GMLC-Address",			/* Name */
				AVP_FLAG_VENDOR,		/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_OCTETSTRING		/* base type of data */
			};

			CHECK_dict_new( DICT_AVP, &data , Address_type, NULL);
		}

		/* Supported Features AVP - 3GPP TS 29.229 */
		{
			struct dict_object * avp;
			struct dict_avp_data data = {
				628,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Supported-Features",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Vendor-Id",			RULE_REQUIRED,  1, 1 }
				,{  "Feature-List-ID",		RULE_REQUIRED,  1, 1 }
				,{  "Feature-List",			RULE_REQUIRED,  1, 1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Trace-Data AVP - 3GPP TS 29.272  #7.3.63 */
		{
			struct dict_object * avp;

			struct dict_avp_data data = {
				1458,				/* Code */
                VENDOR_3GPP_Id,     /* Vendor */
				"Trace-Data",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 { "Trace-Reference",				RULE_REQUIRED, -1,  1 }
				,{ "Trace-Depth",					RULE_REQUIRED, -1,  1 }
				,{ "Trace-NE-Type-List",			RULE_REQUIRED, -1,  1 }
				,{ "Trace-Interface-List",			RULE_OPTIONAL, -1,  1 }
				,{ "Trace-Event-List",				RULE_REQUIRED, -1,  1 }
				,{ "OMC-Id",						RULE_OPTIONAL, -1,  1 }
				,{ "Trace-Collection-Entity",		RULE_REQUIRED, -1,  1 }
				,{ "MDT-Configuration",				RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data, NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Subscription-Data AVP - 3GPP TS 29.272 #7.3.2 */
		{
			/*

			 * The Subscription-Data AVP is of type Grouped. It shall contain
			 * the information related to the user profile relevant for
			 * EPS and GERAN/UTRAN.

			 Subscription-Data ::= <AVP header: 1400 10415>
				[ Subscriber-Status ]
				[ MSISDN ]
				[ STN-SR ]
				[ ICS-Indicator ]
				[ Network-Access-Mode ]
				[ Operator-Determined-Barring ]
				[ HPLMN-ODB ]
			 *10[ Regional-Subscription-Zone-Code]
				[ Access-Restriction-Data ]
				[ APN-OI-Replacement ]
				[ LCS-Info ]
				[ Teleservice-List ]
				[ Call-Barring-Infor-List ]
				[ 3GPP-Charging-Characteristics ]
				[ AMBR ]
				[ APN-Configuration-Profile ]
				[ RAT-Frequency-Selection-Priority-ID ]
				[ Trace-Data]
				[ GPRS-Subscription-Data ]
			   *[ CSG-Subscription-Data ]
				[ Roaming-Restricted-Due-To-Unsupported-Feature ]
				[ Subscribed-Periodic-RAU-TAU-Timer ]
				[ MPS-Priority ]
				[ VPLMN-LIPA-Allowed ]
				[ Relay-Node-Indicator ]
				[ MDT-User-Consent ]
			   *[ AVP ]

			 * The AMBR included in this grouped AVP shall include the AMBR
			 * associated to the user’s subscription (UE-AMBR);
			 * Max-Requested-Bandwidth-UL and Max-Requested-Bandwidth-DL within
			 * this AVP shall not both be set to "0".
			 * The APN-OI-Replacement included in this grouped AVP shall include
			 * the UE level APN-OI-Replacement associated to the user’s subscription.
			 */
			struct dict_object * avp;
			struct dict_avp_data data = {
				1400,				/* Code */
				VENDOR_3GPP_Id,					/* Vendor */
				"Subscription-Data",			/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,		/* Fixed flag values */
				AVP_TYPE_GROUPED		/* base type of data */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Subscriber-Status",				RULE_OPTIONAL, -1,  1 }
				,{  "MSISDN",							RULE_OPTIONAL, -1,  1 }
				,{  "STN-SR",							RULE_OPTIONAL, -1,  1 }
				,{  "ICS-Indicator",					RULE_OPTIONAL, -1,  1 }
				,{  "Network-Access-Mode",				RULE_OPTIONAL, -1,  1 }
				,{  "Operator-Determined-Barring",		RULE_OPTIONAL, -1,  1 }
				,{  "HPLMN-ODB",						RULE_OPTIONAL, -1,  1 }
				,{  "Regional-Subscription-Zone-Code",	RULE_OPTIONAL, -1,  10 }
				,{  "Access-Restriction-Data",			RULE_OPTIONAL, -1,  1 }
				,{  "APN-OI-Replacement",				RULE_OPTIONAL, -1,  1 }
				,{  "LCS-Info",							RULE_OPTIONAL, -1,  1 }
				,{  "Teleservice-List",					RULE_OPTIONAL, -1,  1 }
				,{  "Call-Barring-Infor-List",			RULE_OPTIONAL, -1,  1 }
				,{  "3GPP-Charging-Characteristics",	RULE_OPTIONAL, -1,  1 }
				,{  "AMBR",								RULE_OPTIONAL, -1,  1 }
				,{  "APN-Configuration-Profile",		RULE_OPTIONAL, -1,  1 }
				,{  "RAT-Frequency-Selection-Priority-ID", RULE_OPTIONAL, -1,  1 }
				,{  "Trace-Data",						RULE_OPTIONAL, -1,  1 }
				,{  "GPRS-Subscription-Data",			RULE_OPTIONAL, -1,  1 }
				,{  "CSG-Subscription-Data",			RULE_OPTIONAL, -1, -1 }
				,{  "Roaming-Restricted-Due-To-Unsupported-Feature", RULE_OPTIONAL, -1,  1 }
				,{  "Subscribed-Periodic-RAU-TAU-Timer",	RULE_OPTIONAL, -1,  1 }
				,{  "MPS-Priority",						RULE_OPTIONAL, -1,  1 }
				,{  "VPLMN-LIPA-Allowed",				RULE_OPTIONAL, -1,  1 }
				,{  "Relay-Node-Indicator",				RULE_OPTIONAL, -1,  1 }
				,{  "MDT-User-Consent",					RULE_OPTIONAL, -1,  1 }
			};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* S6A-Update Location Request - 3GPP TS 29.272 #7.2.3 */
		{
			/*

			The Update-Location-Request (ULR) command, indicated by the
			Command-Code field set to 316 and the "R" bit set in
			the Command Flags field, is sent from MME or SGSN to HSS.

			< Update-Location-Request> ::= < Diameter Header: 316, REQ, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
					[ Destination-Host ]
					{ Destination-Realm }
					{ User-Name }
				   *[ Supported-Features ]
					[ Terminal-Information ]
					{ RAT-Type }
					{ ULR-Flags }
					[ UE-SRVCC-Capability ]
					{ Visited-PLMN-Id }
					[ SGSN-Number ]
					[ Homogeneous-Support-of-IMS-Voice-Over-PS-Sessions ]
					[ GMLC-Address ]
				   *[ Active-APN ]
				   *[ AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				316, 					/* Code */
				"Update-Location-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",					RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm",				RULE_REQUIRED,   -1,  1 }
				,{  "User-Name",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Terminal-Information",				RULE_OPTIONAL,   -1,  1 }
				,{  "RAT-Type",							RULE_REQUIRED,	1,  1 }
				,{  "ULR-Flags",						RULE_REQUIRED,	1,  1 }
				,{  "UE-SRVCC-Capability",				RULE_OPTIONAL,   -1,  1 }
				,{  "Visited-PLMN-Id",					RULE_REQUIRED,	1,  1 }
				,{  "SGSN-Number",						RULE_OPTIONAL,   -1,  1 }
				,{  "Homogeneous-Support-of-IMS-Voice-Over-PSSessions", RULE_OPTIONAL, -1, 1 }
				,{  "GMLC-Address", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Active-APN", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* S6A-Update Location Answer - 3GPP TS 29.272 #7.2.4 */
		{
			/*

			The Update-Location-Answer (ULA) command, indicated by the
			Command-Code field set to 316 and the 'R' bit cleared
			in the Command Flags field, is sent from HSS to MME or SGSN.

			< Update-Location-Answer> ::= < Diameter Header: 316, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					[ Result-Code ]
					[ Experimental-Result ]
					[ Error-Diagnostic ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
				   *[ Supported-Features ]
					[ ULA-Flags ]
					[ Subscription-Data ]
				   *[ AVP ]
				   *[ Failed-AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				316, 					/* Code */
				"Update-Location-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Result-Code",						RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result",				RULE_OPTIONAL,   -1,  1 }
				,{  "Error-Diagnostic",					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "ULA-Flags",						RULE_OPTIONAL,   -1,  1 }
				,{  "Subscription-Data",				RULE_OPTIONAL,   -1,  1 }
				,{  "Failed-AVP",						RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* S6A-Cancel-Location-Request - 3GPP TS 29.272 #7.2.7 */
		{
			/*

			The Cancel-Location-Request (CLR) command, indicated by the
			Command-Code field set to 317 and the 'R' bit set in
			the Command Flags field, is sent from HSS to MME or SGSN.

			< Cancel-Location-Request> ::= < Diameter Header: 317, REQ, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
					{ Destination-Host }
					{ Destination-Realm }
					{ User-Name }
				   *[Supported-Features ]
					{ Cancellation-Type }
				   *[ AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				317, 					/* Code */
				"Cancel-Location-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",					RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm",				RULE_REQUIRED,   -1,  1 }
				,{  "User-Name",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Cancellation-Type", 				RULE_REQUIRED,   -1,  1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* S6A-Cancel-Location-Answer - 3GPP TS 29.272 #7.2.8 */
		{
			/*

			The Cancel-Location-Answer (CLA) command, indicated by the
			Command-Code field set to 317 and the 'R' bit cleared
			in the Command Flags field, is sent from MME or SGSN to HSS.

			< Cancel-Location-Answer> ::= < Diameter Header: 317, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
				   *[ Supported-Features ]
					[ Result-Code ]
					[ Experimental-Result ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
				   *[ AVP ]
				   *[ Failed-AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			*/
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				317, 					/* Code */
				"Cancel-Location-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Result-Code",						RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result",				RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Failed-AVP", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* S6A-Authentication-Information-Request - 3GPP TS 29.272 #7.2.4 */
		{
			/*

			The Authentication-Information-Request (AIR) command, indicated by
			the Command-Code field set to 318 and the 'R'
			bit set in the Command Flags field, is sent from MME or SGSN to HSS.

			< Authentication-Information-Request> ::= < Diameter Header: 318, REQ, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
					[ Destination-Host ]
					{ Destination-Realm }
					{ User-Name }
				   *[ Supported-Features ]
					[ Requested-EUTRAN-Authentication-Info ]
					[ Requested-UTRAN-GERAN-Authentication-Info ]
					{ Visited-PLMN-Id }
				   *[ AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				318, 					/* Code */
				"Authentication-Information-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",					RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm",				RULE_REQUIRED,   -1,  1 }
				,{  "User-Name",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Requested-EUTRAN-Authentication-Info", 		RULE_OPTIONAL,   -1,  1 }
				,{  "Requested-UTRAN-GERAN-Authentication-Info", 	RULE_OPTIONAL,   -1,  1 }
				,{  "Visited-PLMN-Id", 					RULE_REQUIRED,   -1,  1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* S6A-Authentication-Information-Answer - 3GPP TS 29.272 #7.2.6 */
		{
			/*

			The Authentication-Information-Answer (AIA) command, indicated by
			the Command-Code field set to318 and the 'R' bit cleared in the
			Command Flags field, is sent from HSS to MME or SGSN.

			< Authentication-Information-Answer> ::= < Diameter Header: 318, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					[ Result-Code ]
					[ Experimental-Result ]
					[ Error-Diagnostic ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
				   *[ Supported-Features ]
					[ Authentication-Info ]
				   *[ AVP ]
				   *[ Failed-AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				318, 					/* Code */
				"Authentication-Information-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Result-Code",						RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result",				RULE_OPTIONAL,   -1,  1 }
				,{  "Error-Diagnostic",					RULE_OPTIONAL,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Authentication-Info", 				RULE_OPTIONAL,   -1,  1 }
				,{  "Failed-AVP", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Insert-Subscriber-Data-Request IDR Command - 3GPP TS 29.272 #7.2.9 */
		{
			/*

			The Insert-Subscriber-Data-Request (IDR) command, indicated by the
			Command-Code field set to 319 and the 'R' bit set in the Command
			Flags field, is sent from HSS to MME or SGSN.

			< Insert-Subscriber-Data-Request> ::= < Diameter Header: 319, REQ, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
					{ Destination-Host }
					{ Destination-Realm }
					{ User-Name }
				   *[ Supported-Features]
					{ Subscription-Data}
					[IDR- Flags ]
				   *[ AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				319, 					/* Code */
				"Insert-Subscriber-Data-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 						RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",	RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State",				RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",					RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Realm",				RULE_REQUIRED,   -1,  1 }
				,{  "User-Name",						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features",				RULE_OPTIONAL,   -1, -1 }
				,{  "Subscription-Data", 				RULE_REQUIRED,   -1,  1 }
				,{  "IDR-Flags", 						RULE_OPTIONAL,   -1,  1 }
				,{  "Proxy-Info", 						RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 					RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Insert-Subscriber-Data-Answer IDA Command - 3GPP TS 29.272 #7.2.10 */
		{
			/*

			The Insert-Subscriber-Data-Request (IDR) command, indicated by the
			Command-Code field set to 319 and the 'R' bit set in the Command
			Flags field, is sent from HSS to MME or SGSN.

			< Insert-Subscriber-Data-Answer> ::= < Diameter Header: 319, PXY, 16777251 >
					< Session-Id >
					[ Vendor-Specific-Application-Id ]
				   *[ Supported-Features ]
					[ Result-Code ]
					[ Experimental-Result ]
					{ Auth-Session-State }
					{ Origin-Host }
					{ Origin-Realm }
					[ IMS-Voice-Over-PS-Sessions-Supported ]
					[ Last-UE-Activity-Time ]
					[ RAT-Type ]
					[ IDA-Flags ]
					[ EPS-User-State ]
					[ EPS-Location-Information ]
				   *[ AVP ]
				   *[ Failed-AVP ]
				   *[ Proxy-Info ]
				   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				319, 					/* Code */
				"Insert-Subscriber-Data-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features",					RULE_OPTIONAL,   -1, -1 }
				,{  "Result-Code", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host", 							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm", 						RULE_REQUIRED,   -1,  1 }
				,{  "IMS-Voice-Over-PS-Sessions-Supported", RULE_OPTIONAL,   -1,  1 }
				,{  "Last-UE-Activity-Time", 				RULE_OPTIONAL,   -1,  1 }
				,{  "RAT-Type", 							RULE_OPTIONAL,   -1,  1 }
				,{  "IDA-Flags", 							RULE_OPTIONAL,   -1,  1 }
				,{  "EPS-User-State", 						RULE_OPTIONAL,   -1,  1 }
				,{  "EPS-Location-Information", 			RULE_OPTIONAL,   -1,  1 }
				,{  "Failed-AVP", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 						RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Delete-Subscriber-Data-Request (DSR) Command - 3GPP TS 29.272 #7.2.11 */
		{
			/*

			The Delete-SubscriberData-Request (DSR) command, indicated by
			the Command-Code field set to 320 and the 'R' bit
			set in the Command Flags field, is sent from HSS to MME or SGSN.

			< Delete-Subscriber-Data-Request > ::= < Diameter Header: 320, REQ, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				{ Destination-Host }
				{ Destination-Realm }
				{ User-Name }
			   *[ Supported-Features ]
				{ DSR-Flags }
			   *[ Context-Identifier ]
				[ Trace-Reference ]
			   *[ TS-Code ]
			   *[ SS-Code ]
			   *[ AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				320, 					/* Code */
				"Delete-SubscriberData-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Realm",					RULE_REQUIRED,   -1,  1 }
				,{  "User-Name", 							RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "DSR-Flags", 							RULE_REQUIRED,   -1,  1 }
				,{  "Context-Identifier", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Trace-Reference",						RULE_OPTIONAL,   -1,  1 }
				,{  "TS-Code",								RULE_OPTIONAL,   -1, -1 }
				,{  "SS-Code",								RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Delete-Subscriber-Data-Answer (DSA) Command - 3GPP TS 29.272 #7.2.12 */
		{
			/*

			The Delete-SubscriberData-Answer (DSA) command, indicated by the
			Command-Code field set to 320 and the 'R' bit
			cleared in the Command Flags field, is sent from MME or SGSN to HSS.

			< Delete-Subscriber-Data-Answer> ::= < Diameter Header: 320, PXY, 16777251 >
			< Session-Id >
			[ Vendor-Specific-Application-Id ]
			*[ Supported-Features ]
			[ Result-Code ]
			[ Experimental-Result ]
			{ Auth-Session-State }
			{ Origin-Host }
			{ Origin-Realm }
			[ DSA-Flags ]
			*[ AVP ]
			*[ Failed-AVP ]
			*[ Proxy-Info ]
			*[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				320, 					/* Code */
				"Delete-SubscriberData-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Result-Code", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "DSA-Flags", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Purge-UE-Request (PUR) Command - 3GPP TS 29.272 #7.2.13 */
		{
			/*

			The Delete-SubscriberData-Request (DSR) command, indicated by
			the Command-Code field set to 320 and the 'R' bit
			set in the Command Flags field, is sent from HSS to MME or SGSN.

			< Purge-UE-Request> ::= < Diameter Header: 321, REQ, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				[ Destination-Host ]
				{ Destination-Realm }
				{ User-Name }
				[ PUR-Flags ]
			   *[ Supported-Features ]
			   *[ AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				321, 					/* Code */
				"Purge-UE-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",						RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm",					RULE_REQUIRED,   -1,  1 }
				,{  "User-Name", 							RULE_REQUIRED,   -1,  1 }
				,{  "PUR-Flags", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Purge-UE-Answer (PUA) Command - 3GPP TS 29.272 #7.2.14 */
		{
			/*

			 The Purge-UE-Answer (PUA) command, indicated by the Command-Code
			 field set to 321 and the 'R' bit cleared in the
			 Command Flags field, is sent from HSS to MME or SGSN.

			 < Purge-UE-Answer> ::= < Diameter Header: 321, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
			   *[ Supported-Features ]
				[ Result-Code ]
				[ Experimental-Result ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				[ PUA-Flags ]
			   *[ AVP ]
			   *[ Failed-AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				321, 					/* Code */
				"Purge-UE-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Result-Code", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "PUA-Flags", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Failed-AVP",							RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Reset-Request (RSR) Command - 3GPP TS 29.272 #7.2.15 */
		{
			/*

			The Reset-Request (RSR) command, indicated by the Command-Code
			field set to 322 and the 'R' bit set in the
			Command Flags field, is sent from HSS to MME or SGSN.

			< Reset-Request> ::= < Diameter Header: 322, REQ, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				{ Destination-Host }
				{ Destination-Realm }
			   *[ Supported-Features ]
			   *[ User-Id ]
			   *[ AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				322, 					/* Code */
				"Reset-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host",						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Realm",					RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "User-Id", 								RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Reset-Answer (RSA) Command - 3GPP TS 29.272 #7.2.16 */
		{
			/*

			The Authentication-Information-Answer (RSA) command, indicated by
			the Command-Code field set to 322 and the 'R'
			bit cleared in the Command Flags field, is sent from MME or SGSN to HSS.

			< Reset-Answer> ::= < Diameter Header: 322, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
			   *[ Supported-Features ]
				[ Result-Code ]
				[ Experimental-Result ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
			   *[ AVP ]
			   *[ Failed-AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				322, 					/* Code */
				"Reset-Anwer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id",							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Result-Code", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host",							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm",							RULE_REQUIRED,   -1,  1 }
				,{  "Failed-AVP", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info",							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record",							RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Notify-Request (NOR) Command - 3GPP TS 29.272 #7.2.17 */
		{
			/*

			The Notify-Request (NOR) command, indicated by the Command-Code
			field set to 323 and the 'R' bit set in the Command Flags field,
			is sent from MME or SGSN to HSS.

			< Notify-Request> ::= < Diameter Header: 323, REQ, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				[ Destination-Host ]
				{ Destination-Realm }
				{ User-Name }
			   *[ Supported-Features ]
				[ Terminal-Information ]
				[ MIP6-Agent-Info ]
				[ Visited-Network-Identifier ]
				[ Context-Identifier ]
				[ Service-Selection ]
				[ Alert-Reason ]
				[ UE-SRVCC-Capability ]
				[ NOR-Flags ]
			   *[ AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				323, 					/* Code */
				"Notify-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host", 							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm", 						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm", 					RULE_REQUIRED,   -1,  1 }
				,{  "User-Name", 							RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Terminal-Information", 				RULE_OPTIONAL,   -1,  1 }
				,{  "MIP6-Agent-Info", 						RULE_OPTIONAL,   -1,  1 }
				,{  "Visited-Network-Identifier", 			RULE_OPTIONAL,   -1,  1 }
				,{  "Context-Identifier", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Service-Selection", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Alert-Reason", 						RULE_OPTIONAL,   -1,  1 }
				,{  "UE-SRVCC-Capability", 					RULE_OPTIONAL,   -1,  1 }
				,{  "NOR-Flags", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Proxy-Info", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 						RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* Notify-Answer (NOA) Command - 3GPP TS 29.272 #7.2.18 */
		{
			/*

			The Notify-Answer (NOA) command, indicated by the Command-Code
			field set to 323 and the 'R' bit cleared in the
			Command Flags field, is sent from HSS to MME or SGSN.

			< Notify-Answer> ::= < Diameter Header: 323, PXY, 16777251 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				[ Result-Code ]
				[ Experimental-Result ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
			   *[ Supported-Features ]
			   *[ AVP ]
			   *[ Failed-AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				323, 					/* Code */
				"Notify-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Result-Code",							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result",					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host", 							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm", 						RULE_REQUIRED,   -1,  1 }
				,{  "Supported-Features", 					RULE_OPTIONAL,   -1, -1 }
				,{  "Failed-AVP", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 						RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* ME-Identity-Check-Request (ECR) Command - 3GPP TS 29.272 #7.2.19 */
		{
			/*

			The ME-Identity-Check-Request (ECR) command, indicated by the
			Command-Code field set to 324 and the 'R' bit set
			in the Command Flags field, is sent from MME or SGSN to EIR.

			< ME-Identity-Check-Request > ::= < Diameter Header: 324, REQ, PXY, 16777252 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				[ Destination-Host ]
				{ Destination-Realm }
				{ Terminal-Information }
				[ User-Name ]
			   *[ AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				324, 					/* Code */
				"ME-Identity-Check-Request", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host", 							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm", 						RULE_REQUIRED,   -1,  1 }
				,{  "Destination-Host", 					RULE_OPTIONAL,   -1,  1 }
				,{  "Destination-Realm", 					RULE_REQUIRED,   -1,  1 }
				,{  "Terminal-Information",					RULE_REQUIRED,   -1,  1 }
				,{  "User-Name", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Proxy-Info", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 						RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}

		/* ME-Identity-Check-Answer (ECA) Command - 3GPP TS 29.272 #7.2.20 */
		{
			/*

			The ME-Identity-Check-Answer (ECA) command, indicated by the
			Command-Code field set to 324 and the 'R' bit
			cleared in the Command Flags field, is sent from EIR to MME or SGSN.

			< ME-Identity-Check-Answer> ::= < Diameter Header: 324, PXY, 16777252 >
				< Session-Id >
				[ Vendor-Specific-Application-Id ]
				[ Result-Code ]
				[ Experimental-Result ]
				{ Auth-Session-State }
				{ Origin-Host }
				{ Origin-Realm }
				[ Equipment-Status ]
			   *[ AVP ]
			   *[ Failed-AVP ]
			   *[ Proxy-Info ]
			   *[ Route-Record ]
			 */
			struct dict_object * cmd;
			struct dict_cmd_data data = {
				324, 					/* Code */
				"ME-Identity-Check-Answer", 			/* Name */
				CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, 	/* Fixed flags */
				CMD_FLAG_PROXIABLE 						/* Fixed flag values */
			};

			struct local_rules_definition rules[] =
			{
				 {  "Session-Id", 							RULE_FIXED_HEAD, -1,  1 }
				,{  "Vendor-Specific-Application-Id",		RULE_OPTIONAL,   -1,  1 }
				,{  "Result-Code",							RULE_OPTIONAL,   -1,  1 }
				,{  "Experimental-Result",					RULE_OPTIONAL,   -1,  1 }
				,{  "Auth-Session-State", 					RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Host", 							RULE_REQUIRED,   -1,  1 }
				,{  "Origin-Realm", 						RULE_REQUIRED,   -1,  1 }
				,{  "Equipment-Status",						RULE_OPTIONAL,   -1,  1 }
				,{  "User-Name", 							RULE_OPTIONAL,   -1,  1 }
				,{  "Failed-AVP", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Proxy-Info", 							RULE_OPTIONAL,   -1, -1 }
				,{  "Route-Record", 						RULE_OPTIONAL,   -1, -1 }
			};

			CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd);
			PARSE_loc_rules( rules, cmd );
		}
	}

	TRACE_DEBUG(INFO, "Dictionary Extension 'S6A from 3GPP standard v.10.5' initialized");
	return 0;
}
EXTENSION_ENTRY("dict_s6a", dict_s6a_init, "dict_nas_mipv6");
